JavaScript Temporal Instant: Augstas Precizitātes Laika Aprēķini

JavaScript jau sen ir pazīstams ar savām ne visai ideālajām datuma un laika apstrādes iespējām. Mantotais Date objekts, lai arī plaši izmantots, cieš no mainīguma, nekonsekventas API uzvedības un vāja laika joslu atbalsta. Ienāk Temporal API — moderna pieeja datuma un laika manipulācijām, kas izstrādāta, lai novērstu šos trūkumus. Temporal pamatā ir Instant objekts, kas attēlo konkrētu laika punktu ar nanosekundes precizitāti. Šis emuāra ieraksts sniedz visaptverošu ceļvedi par Temporal.Instant izmantošanu augstas precizitātes laika aprēķiniem jūsu JavaScript lietojumprogrammās, apmierinot globālas auditorijas daudzveidīgās vajadzības.

Kas ir Temporal.Instant?

Temporal.Instant attēlo laika punktu, kas mērīts no Unix epohas (1970. gada 1. janvāris, 00:00:00 Koordinētais universālais laiks (UTC)) ar nanosekundes precizitāti. Atšķirībā no mantotā Date objekta, Temporal.Instant ir nemainīgs, kas nozīmē, ka tā vērtību nevar mainīt pēc izveides. Šī nemainība ir būtiska, lai novērstu negaidītas blakusparādības un nodrošinātu datu integritāti, īpaši sarežģītās lietojumprogrammās.

Temporal.Instant Objektu Izveide

Ir vairāki veidi, kā izveidot Temporal.Instant objektus:

1. No Skaitļa (Milisekundes Kopš Epohas)

Jūs varat izveidot Instant no milisekunžu skaita, kas pagājušas kopš Unix epohas. Tas ir līdzīgi kā darbojas mantotais Date objekts, bet Temporal.Instant piedāvā lielāku precizitāti.

            
const instant = Temporal.Instant.fromEpochMilliseconds(1678886400000); // March 15, 2023, 00:00:00 UTC
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

            

              
                Copy
              
            
          

2. No Skaitļa (Nanosekundes Kopš Epohas)

Vēl lielākai precizitātei jūs varat izveidot Instant no nanosekunžu skaita, kas pagājušas kopš Unix epohas. Šis ir visprecīzākais veids, kā attēlot laika punktu ar Temporal.Instant.

            
const instant = Temporal.Instant.fromEpochNanoseconds(1678886400000000000n); // March 15, 2023, 00:00:00 UTC
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

            

              
                Copy
              
            
          

Ievērojiet n sufiksa lietojumu, lai norādītu BigInt literāli. Nanosekunžu vērtības bieži pārsniedz maksimālo drošo veselo skaitļu vērtību JavaScript skaitļiem, tāpēc BigInt izmantošana ir nepieciešama, lai saglabātu precizitāti.

3. No ISO 8601 Virknes

Temporal.Instant var izveidot arī no ISO 8601 virknes, kas attēlo UTC datumu un laiku.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
console.log(instant.toString()); // Output: 2023-03-15T00:00:00Z

const instantWithFractionalSeconds = Temporal.Instant.from('2023-03-15T00:00:00.123456789Z');
console.log(instantWithFractionalSeconds.toString()); // Output: 2023-03-15T00:00:00.123456789Z

            

              
                Copy
              
            
          

ISO 8601 virknei jābeidzas ar Z, lai norādītu UTC. Virkne pēc izvēles var ietvert sekundes daļas ar līdz pat deviņiem cipariem precizitāti.

4. No Temporal.Now (Sistēmas Pulkstenis)

Jūs varat iegūt pašreizējo laika momentu, izmantojot Temporal.Now.instant():

            
const now = Temporal.Now.instant();
console.log(now.toString()); // Output: Varies depending on the current time

            

              
                Copy
              
            
          

Darbs ar Temporal.Instant Objektiem

Kad jums ir Temporal.Instant objekts, varat ar to veikt dažādas darbības. Atcerieties, ka Temporal.Instant objekti ir nemainīgi, tāpēc šīs darbības atgriež jaunus Temporal.Instant objektus, nevis modificē oriģinālu.

1. Laika Pievienošana un Atņemšana

Jūs varat pievienot vai atņemt laiku no Instant, izmantojot add() un subtract() metodes. Šīs metodes pieņem Temporal.Duration objektu, kas attēlo laika posmu.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const duration = Temporal.Duration.from({ hours: 2, minutes: 30 });

const futureInstant = instant.add(duration);
console.log(futureInstant.toString()); // Output: 2023-03-15T02:30:00Z

const pastInstant = instant.subtract(duration);
console.log(pastInstant.toString()); // Output: 2023-03-14T21:30:00Z

            

              
                Copy
              
            
          

Jūs varat izmantot arī virknes attēlojumu ilgumam:

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const futureInstant = instant.add('PT2H30M'); // ISO 8601 duration string
console.log(futureInstant.toString()); // Output: 2023-03-15T02:30:00Z

            

              
                Copy
              
            
          

2. Momentu Salīdzināšana

Jūs varat salīdzināt divus Temporal.Instant objektus, izmantojot compare() metodi. Šī metode atgriež:

• -1, ja pirmais moments ir agrāks par otro.
• 0, ja abi momenti ir vienādi.
• 1, ja pirmais moments ir vēlāks par otro.

            
const instant1 = Temporal.Instant.from('2023-03-15T00:00:00Z');
const instant2 = Temporal.Instant.from('2023-03-15T01:00:00Z');

console.log(Temporal.Instant.compare(instant1, instant2)); // Output: -1
console.log(Temporal.Instant.compare(instant2, instant1)); // Output: 1
console.log(Temporal.Instant.compare(instant1, instant1)); // Output: 0

            

              
                Copy
              
            
          

3. Pārveidošana Citos Temporal Tipos

Temporal.Instant var pārveidot citos Temporal tipos, piemēram, Temporal.ZonedDateTime, Temporal.PlainDateTime un Temporal.PlainDate. Tas ir būtiski, strādājot ar laika joslām un lokalizētiem datuma un laika attēlojumiem.

a. Uz Temporal.ZonedDateTime

Temporal.ZonedDateTime attēlo datumu un laiku ar konkrētu laika joslu. Lai pārveidotu Instant par ZonedDateTime, jums ir jānorāda laika josla.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
console.log(zonedDateTime.toString()); // Output: 2023-03-14T17:00:00-07:00[America/Los_Angeles]

            

              
                Copy
              
            
          

toZonedDateTimeISO() metode izveido ZonedDateTime, izmantojot ISO 8601 kalendāru. Jūs varat arī izmantot toZonedDateTime(), lai norādītu citu kalendāru.

b. Uz Temporal.PlainDateTime

Temporal.PlainDateTime attēlo datumu un laiku bez laika joslas. Lai pārveidotu Instant par PlainDateTime, jums vispirms tas jāpārveido par ZonedDateTime un pēc tam no tā jāiegūst PlainDateTime.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
const plainDateTime = zonedDateTime.toPlainDateTime();
console.log(plainDateTime.toString()); // Output: 2023-03-14T17:00:00

            

              
                Copy
              
            
          

c. Uz Temporal.PlainDate

Temporal.PlainDate attēlo datumu bez laika vai laika joslas. Līdzīgi kā ar PlainDateTime, vispirms jāveic pārveidošana uz ZonedDateTime.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO('America/Los_Angeles');
const plainDate = zonedDateTime.toPlainDate();
console.log(plainDate.toString()); // Output: 2023-03-14

            

              
                Copy
              
            
          

4. Milisekunžu un Nanosekunžu Iegūšana Kopš Epohas

Jūs varat iegūt milisekunžu vai nanosekunžu skaitu, kas pagājis kopš Unix epohas, izmantojot attiecīgi epochMilliseconds un epochNanoseconds īpašības.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00.123456789Z');
console.log(instant.epochMilliseconds); // Output: 1678886400123
console.log(instant.epochNanoseconds); // Output: 1678886400123456789n

            

              
                Copy
              
            
          

Temporal.Instant Pielietojuma Gadījumi

Temporal.Instant ir īpaši noderīgs scenārijos, kur nepieciešami augstas precizitātes laika aprēķini. Šeit ir daži piemēri:

1. Notikumu Reģistrēšana un Audits

Reģistrējot notikumus vai veicot sistēmas darbību auditu, ir ļoti svarīgi fiksēt precīzu laiku, kad notikums noticis. Temporal.Instant nodrošina nepieciešamo precizitāti, lai precīzi reģistrētu laika zīmogus.

            
function logEvent(eventDescription) {
  const timestamp = Temporal.Now.instant().toString();
  console.log(`[${timestamp}] ${eventDescription}`);
}

logEvent('User logged in');
logEvent('File saved');

            

              
                Copy
              
            
          

2. Veiktspējas Mērīšana

Koda veiktspējas mērīšanai nepieciešama precīza laika uzskaite. Temporal.Instant var izmantot, lai mērītu koda bloku izpildes laiku ar nanosekundes precizitāti.

            
const start = Temporal.Now.instant();
// Code to measure
for (let i = 0; i < 1000000; i++) {
  // Some operation
}
const end = Temporal.Now.instant();

const duration = end.since(start);
console.log(`Execution time: ${duration.total('milliseconds')} milliseconds`);

            

              
                Copy
              
            
          

3. Izkliedētās Sistēmas un Datu Sinhronizācija

Izkliedētās sistēmās datu konsekvences uzturēšanai starp vairākiem mezgliem bieži nepieciešama precīza laika sinhronizācija. Temporal.Instant var izmantot, lai attēlotu laika zīmogus datu atjauninājumiem un risinātu konfliktus, pamatojoties uz laiku.

Piemēram, apsveriet scenāriju, kur dati tiek replicēti vairākos serveros dažādās ģeogrāfiskās vietās (piemēram, satura piegādes tīklā vai izkliedētā datu bāzē). Ja lietotājs atjaunina ierakstu, sistēmai jānodrošina, ka jaunākais atjauninājums tiek konsekventi izplatīts visos serveros. Izmantojot Temporal.Instant, lai katram atjauninājumam piešķirtu laika zīmogu, tiek nodrošināta precīza secība, pat ar tīkla latentumu un iespējamo pulksteņa nobīdi starp serveriem.

4. Finanšu Darījumi

Finanšu darījumiem bieži nepieciešami augstas precizitātes laika zīmogi, lai nodrošinātu atbilstību normatīvajiem aktiem un precīzu uzskaiti. Precīzs tirdzniecības, maksājuma vai pārskaitījuma laiks ir jāreģistrē precīzi, lai izvairītos no strīdiem un nodrošinātu atbildību.

Piemēram, augstfrekvences tirdzniecības sistēmas prasa mikrosekundes vai nanosekundes precizitāti, lai fiksētu precīzu brīdi, kad tiek izpildīts rīkojums. Pat nelielas laika neatbilstības var radīt būtiskas finansiālas sekas. Temporal.Instant nodrošina nepieciešamo izšķirtspēju šīm kritiskajām lietojumprogrammām.

5. Zinātniskie Pielietojumi

Daudzām zinātniskām lietojumprogrammām, piemēram, astronomijai, fizikas simulācijām un datu reģistrēšanai no eksperimentiem, nepieciešami ļoti precīzi laika mērījumi. Šie mērījumi bieži ir būtiski datu analīzei un precīzu secinājumu izdarīšanai.

Iedomājieties teleskopu, kas vāc datus no tālas zvaigznes. Katra novērojuma precīzais laiks ir būtisks, lai noteiktu zvaigznes stāvokli, kustību un citas īpašības. Temporal.Instant ļauj zinātniekiem reģistrēt šos laika zīmogus ar nepieciešamo precizitāti.

Internacionalizācija un Laika Joslas

Lai gan Temporal.Instant attēlo laika punktu UTC, ir svarīgi ņemt vērā laika joslas, strādājot ar datumiem un laikiem globālai auditorijai. Kā parādīts iepriekš, jūs varat pārveidot Instant par Temporal.ZonedDateTime, lai attēlotu to pašu laika punktu konkrētā laika joslā.

Rādot datumus un laikus lietotājiem, vienmēr izmantojiet viņu vietējo laika joslu, lai izvairītos no neskaidrībām. Jūs varat iegūt lietotāja laika joslu no viņa pārlūkprogrammas vai operētājsistēmas. Piemēram, jūs varētu izmantot Intl.DateTimeFormat API, lai formatētu datumu un laiku atbilstoši lietotāja lokalizācijai un laika joslai.

            
const instant = Temporal.Instant.from('2023-03-15T00:00:00Z');
const zonedDateTime = instant.toZonedDateTimeISO(Temporal.Now.timeZone());

const formatter = new Intl.DateTimeFormat(undefined, {
  year: 'numeric',
  month: 'long',
  day: 'numeric',
  hour: 'numeric',
  minute: 'numeric',
  timeZoneName: 'short',
});

console.log(formatter.format(zonedDateTime)); // Output: Varies depending on the user's locale and time zone

            

              
                Copy
              
            
          

Šis piemērs izmanto lietotāja sistēmas laika joslu. Jūs varat aizstāt Temporal.Now.timeZone() ar konkrētu laika joslas identifikatoru (piemēram, 'America/Los_Angeles'), ja nepieciešams.

Piezīme: Strādājot ar laika joslām, vienmēr ņemiet vērā vasaras laiku (DST). Laika joslu noteikumi var mainīties, tāpēc ir svarīgi izmantot aktuālu laika joslu datu bāzi, lai nodrošinātu precīzus aprēķinus. Temporal API automātiski apstrādā DST pārejas, pārveidojot starp laika joslām.

Pārlūkprogrammu un Vides Atbalsts

Sākot ar 2023. gada beigām, Temporal API joprojām ir salīdzinoši jauns un vēl nav pilnībā atbalstīts visās pārlūkprogrammās un JavaScript vidēs. Jums varētu būt nepieciešams izmantot polyfill, lai nodrošinātu atbalstu vecākām pārlūkprogrammām.

@js-temporal/polyfill pakotne nodrošina polyfill Temporal API. Jūs varat to instalēt, izmantojot npm vai yarn:

            
npm install @js-temporal/polyfill

            

              
                Copy
              
            
          

Pēc tam importējiet polyfill savā JavaScript kodā:

            
import '@js-temporal/polyfill';

            

              
                Copy
              
            
          

Tas pievienos Temporal API globālajai darbības jomai, ļaujot to izmantot savā kodā, pat ja vide to dabiski neatbalsta.

Labākās Prakses un Apsvērumi

• Iekšējai glabāšanai un aprēķiniem izmantojiet UTC: Glabājiet visus laika zīmogus UTC, lai izvairītos no ar laika joslām saistītām problēmām. Pārveidojiet uz vietējām laika joslām tikai tad, kad rādāt datumus un laikus lietotājiem.
• Rūpīgi veiciet laika joslu pārveidošanu: Esiet informēts par DST un laika joslu noteikumu izmaiņām. Izmantojiet aktuālu laika joslu datu bāzi, lai nodrošinātu precīzas pārveidošanas.
• Nanosekunžu vērtībām izmantojiet BigInt: Nanosekunžu vērtības bieži pārsniedz maksimālo drošo veselo skaitļu vērtību JavaScript skaitļiem. Izmantojiet BigInt, lai saglabātu precizitāti.
• Apsveriet polyfill izmantošanu: Ja jums ir jāatbalsta vecākas pārlūkprogrammas vai vides, izmantojiet @js-temporal/polyfill pakotni.
• Rūpīgi pārbaudiet savu kodu: Pārbaudiet savu kodu ar dažādām laika joslām un lokalizācijām, lai nodrošinātu, ka tas pareizi darbojas visiem lietotājiem.
• Dokumentējiet savus pieņēmumus: Skaidri dokumentējiet visus pieņēmumus, ko veicat par laika joslām, lokalizācijām vai datuma un laika formātiem.

Noslēgums

Temporal.Instant nodrošina robustu un precīzu veidu, kā attēlot laika punktus JavaScript. Tā nemainība, nanosekundes precizitāte un integrācija ar citiem Temporal tipiem padara to par spēcīgu rīku sarežģītu laika aprēķinu veikšanai dažādās lietojumprogrammās. Izprotot, kā izveidot, manipulēt un salīdzināt Instant objektus, un ievērojot labākās prakses internacionalizācijai un laika joslu apstrādei, jūs varat veidot uzticamu un precīzu datuma un laika funkcionalitāti globālai auditorijai. Temporal API, ieskaitot Instant objektu, pieņemšana ļauj izstrādātājiem pārsniegt mantotā Date objekta ierobežojumus un veidot robustākas un uzturamākas lietojumprogrammas, kas precīzi atspoguļo laika sarežģītību dažādās kultūrās un reģionos.

Tā kā Temporal API gūst plašāku pielietojumu, tas ir gatavs kļūt par standartu datuma un laika manipulācijām JavaScript. Izstrādātāji, kas iepazīsies ar tā funkcijām un labākajām praksēm, būs labi sagatavoti, lai veidotu nākamās paaudzes laika apzinošas lietojumprogrammas.